/*
尽可能还原 Promise 中的每一个 API, 并通过注释的方式描述思路和原理.
*/

const PENDING = 'pending'; // 等待
const FULFILLED = 'fulfilled'; // 成功
const REJECTED = 'rejected'; // 失败

class MyPromise {
    constructor(executor) {
        // 这里需要处理执行器出错的情况
        try{
            executor(this.resolve, this.reject)
        } catch(e) {
            this.reject(e)
        }
    }
    status = PENDING; //初始状态为等待
    value = undefined; //初始的成功值
    reason = undefined; //失败的初始值
    successCallback = []; //存储成功的初始值
    failCallback = []; //存储失败的初始值
    resolve = value => {
        // 成功方式
        if (this.status !== PENDING) return // 状态一旦确定就不能在改变
        this.status = FULFILLED;
        this.value = value; // 保存成功值
        // this.successCallback && this.successCallback(this.value)  单个可以这样写
        while(this.successCallback.length) {
            this.successCallback.shift()()
        }
    }
    reject = reason => {
        //失败方法
        if (this.status !== PENDING) return // 状态一旦确定就不能在改变
        this.status = REJECTED;
        this.reason = reason; // 保存失败值
        // this.failCallback && this.failCallback(this.reason)  单个可以这样写
        while(this.failCallback.length) {
            this.failCallback.shift()()
        }
    }
    then(successCallback, failCallback) { // then方法接受成功回调和失败回调两个参数
        // 链式调用不传参默认传入过去
        successCallback = successCallback ? successCallback : value => value
        failCallback = failCallback ? failCallback : reason => {throw reason}
        // 实现then的链式调用，这里需要new MyPromise
        const myPromise = new MyPromise((resolve, reject) => {
            // 判断状态，成功走成功回调，失败走失败回调
            if(this.status === FULFILLED) {
                // 这里在函数体里面拿不到函数值，所以使用异步的方式获取
                setTimeout(() => {
                    // 这里也需要处理回调失败的情况
                    try{
                        const v = successCallback(this.value)
                        resolveMyPromise(myPromise, v, resolve, reject) // 这里需要对返回的值做判断，如果是普通值就直接返回，如果是promise对象就需要再次调用
                    }catch(e){
                        reject(e)
                    }
                }, 0)
            } else if(this.status === REJECTED) {
                // 这里在函数体里面拿不到函数值，所以使用异步的方式获取
                setTimeout(() => {
                    // 这里也需要处理回调失败的情况
                    try{
                        const v = failCallback(this.reason)
                        resolveMyPromise(myPromise, v, resolve, reject) // 这里需要对返回的值做判断，如果是普通值就直接返回，如果是promise对象就需要再次调用
                    }catch(e){
                        reject(e)
                    }
                }, 0)
            } else { //异步处理
                this.successCallback.push(() => {
                    setTimeout(() => {
                        // 这里也需要处理回调失败的情况
                        try{
                            const v = successCallback(this.value)
                            resolveMyPromise(myPromise, v, resolve, reject) // 这里需要对返回的值做判断，如果是普通值就直接返回，如果是promise对象就需要再次调用
                        }catch(e){
                            reject(e)
                        }
                    }, 0)
                });
                this.failCallback.push(() => {
                    setTimeout(() => {
                        // 这里也需要处理回调失败的情况
                        try{
                            const v = failCallback(this.reason)
                            resolveMyPromise(myPromise, v, resolve, reject) // 这里需要对返回的值做判断，如果是普通值就直接返回，如果是promise对象就需要再次调用
                        }catch(e){
                            reject(e)
                        }
                    }, 0)
                });
            }
        })
        return myPromise
    }
    catch(failCallback) {
        return this.then(undefined, failCallback)
    }
    finally(callback) {
        return this.then(value => {
            MyPromise.resolve(callback()).then(() => value)
        },reason => {
            MyPromise.resolve(callback()).then(() => {throw reason})
        })
    }
    static all(arr) {
        let result = []
        let num = 0
        return new MyPromise((resolve, reject) => {
            function handle(key, value) {
                result[key] = value
                num++
                if (num === arr.length) {
                    resolve(result)
                }
            }
            for(let i = 0; i < arr.length; i++){
                const current = arr[i]
                if(current instanceof MyPromise) {
                    current.then(value => {handle(i, value)}, reason => reject(reason))
                } else {
                    handle(i, current)
                }
            }
        })
    }
    static resolve(val){
       if (val instanceof MyPromise) {
           return val
       }
       return new MyPromise(resolve => resolve(val))
    }
}
function resolveMyPromise(myPromise, v, resolve, reject) {
    if (myPromise === v) {
        return reject(new TypeError('自己不能调用自己，类型错误'))
    }
    if (v instanceof MyPromise) {
        v.then(val => resolve(val), err => reject(err))
    }else {
        resolve(v)
    }
}


module.exports = MyPromise